As semiconductor fabrication technology advances, processor operating frequencies, transistor densities, and computing powers all rise. The gains in density, speed, and computing power of processors are generally accompanied by increases in power consumption. Increased power consumption is objectionable, particularly in portable, mobile, and space applications, because of weight and volume constraints imposed by these applications on power sources. Moreover, power consumption is directly related to heat generation, which is also unwelcome, because the generated heat must somehow be dissipated in order to avoid exceeding specified operating temperature limits and prevent thermal system failures.
Several techniques are known for controlling power consumption in modern processors. Because power consumption at a given operating voltage is often linearly related to the operating frequency of a processor, many processors may be configured to operate at variable clock frequencies, with decreased power consumption at lower frequencies achieved at the cost of decreased computational performance. There is generally a lower limit to the clock frequency of a given processor, below which the processor should not be operated. Thus, decreasing frequency alone may not sufficiently lower power consumption and heat generation.
Moreover, running a processor at a low frequency in a real-time system entails a risk of inadequate processor performance at a critical time. For example, data transfers and other external interactions of a processor can fail if the processor speed is inadequate for the required performance. In some systems, such malfunctions can cause severe adverse consequences, including total mission failures. Such potential consequences can make the use of this power conservation technique inadvisable.
In accordance with another technique, some processors have one or more dormant states in which their power consumption is reduced to one degree or another. The dormant states may include “sleep,” “nap,” and “doze” states. Generally, the processor is brought out of such a dormant state with an interrupt. Some dormant states are associated with excessive latency, i.e., time or number of clock cycles that it takes to enter and especially exit the state. This is problematic in real-time systems when a response to external stimuli must be timely. Even if a dormant state has a relatively short latency, interrupts are not always predictable, particularly in real-time systems, so that specific power savings generally cannot be guaranteed through the use of a dormant state. For example, an interrupt may occur soon after a processor enters a dormant state, preventing power savings even after the interrupt is serviced.
Some operating systems employ “discretized” timing systems with task schedulers and low priority idle tasks for allocating computational time of a processor. The OS relies on a periodic “quantum” interrupt, typically in the range of 10-16 milliseconds, to run a task scheduler. At each quantum interrupt occurrence, the task scheduler runs and decides whether there are any application tasks that need to run during the associated (immediately following) time slice, and the order in which the tasks should be run according to their respective priorities. The task scheduler then runs the application tasks in the order determined, until they are done. If all the tasks are completed before the next scheduler interrupt, the task scheduler runs a low priority idle task. Because the idle task has low priority, the processor can respond to any interrupts (including non-task scheduler interrupts, for example, interrupts from external stimuli) within a relatively short time period, enabling the system to respond to the stimuli in real time. During the idle task, the processor is active and consequently continues to dissipate substantial power.
Merely causing a processor to enter a dormant state through a conventional user application task (i.e., a non-operating system task) would save some power, but the power savings would last only until the next occurrence of the application scheduler or another interrupt. Furthermore, application tasks may cause the processor not to enter a dormant state for sufficiently long periods, causing the power consumption in the processor to exceed the total power budget allocated to the processor.